// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.amazon.fbm.refund.orders;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.AmazonFbmRefundOrders;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(AmazonFbmRefundOrders.class)
@Setter
@Getter
public class AmazonFbmRefundOrdersSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "AmazonFbmRefundOrders".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 亚马逊订单id(模糊搜索)
   */
  private String orderId;

  /**
   * 亚马逊订单id 比较(eq)
   */
  private String orderIdEq;
  /**
   * 亚马逊订单id 比较(neq)
   */
  private String orderIdNeq;
  /**
   * 亚马逊订单id 比较(gt)
   */
  private String orderIdGt;
  /**
   * 亚马逊订单id 比较(gte)
   */
  private String orderIdGte;
  /**
   * 亚马逊订单id 比较(lt)
   */
  private String orderIdLt;
  /**
   * 亚马逊订单id 比较(lte)
   */
  private String orderIdLte;
  /**
   * 亚马逊订单id 比较(contains)
   */
  private String orderIdContains;
  /**
   * 亚马逊订单id 比较(notcontains)
   */
  private String orderIdNotcontains;
  /**
   * 亚马逊订单id 比较(startswith)
   */
  private String orderIdStartswith;
  /**
   * 亚马逊订单id 比较(endswith)
   */
  private String orderIdEndswith;
  /**
   * 亚马逊订单id 比较(isnull)
   */
  private Boolean orderIdIsnull;
  /**
   * 亚马逊订单id 比较(isnotnull)
   */
  private Boolean orderIdIsnotnull;

  /**
   * 亚马逊订单id(精确搜索)
   */
  private List<String> orderIdInList;

  /**
   * 最早订购时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderDateStart;

  /**
   * 最晚订购时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderDateEnd;

  /**
   * 订购时间 比较(eq)
   */
  private Date orderDateEq;
  /**
   * 订购时间 比较(neq)
   */
  private Date orderDateNeq;
  /**
   * 订购时间 比较(gt)
   */
  private Date orderDateGt;
  /**
   * 订购时间 比较(gte)
   */
  private Date orderDateGte;
  /**
   * 订购时间 比较(lt)
   */
  private Date orderDateLt;
  /**
   * 订购时间 比较(lte)
   */
  private Date orderDateLte;
  /**
   * 订购时间 比较(contains)
   */
  private Date orderDateContains;
  /**
   * 订购时间 比较(notcontains)
   */
  private Date orderDateNotcontains;
  /**
   * 订购时间 比较(startswith)
   */
  private Date orderDateStartswith;
  /**
   * 订购时间 比较(endswith)
   */
  private Date orderDateEndswith;
  /**
   * 订购时间 比较(isnull)
   */
  private Boolean orderDateIsnull;
  /**
   * 订购时间 比较(isnotnull)
   */
  private Boolean orderDateIsnotnull;

  /**
   * 最早退货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date returnRequestDateStart;

  /**
   * 最晚退货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date returnRequestDateEnd;

  /**
   * 退货时间 比较(eq)
   */
  private Date returnRequestDateEq;
  /**
   * 退货时间 比较(neq)
   */
  private Date returnRequestDateNeq;
  /**
   * 退货时间 比较(gt)
   */
  private Date returnRequestDateGt;
  /**
   * 退货时间 比较(gte)
   */
  private Date returnRequestDateGte;
  /**
   * 退货时间 比较(lt)
   */
  private Date returnRequestDateLt;
  /**
   * 退货时间 比较(lte)
   */
  private Date returnRequestDateLte;
  /**
   * 退货时间 比较(contains)
   */
  private Date returnRequestDateContains;
  /**
   * 退货时间 比较(notcontains)
   */
  private Date returnRequestDateNotcontains;
  /**
   * 退货时间 比较(startswith)
   */
  private Date returnRequestDateStartswith;
  /**
   * 退货时间 比较(endswith)
   */
  private Date returnRequestDateEndswith;
  /**
   * 退货时间 比较(isnull)
   */
  private Boolean returnRequestDateIsnull;
  /**
   * 退货时间 比较(isnotnull)
   */
  private Boolean returnRequestDateIsnotnull;

  /**
   * 退货状态(模糊搜索)
   */
  private String returnRequestStatus;

  /**
   * 退货状态 比较(eq)
   */
  private String returnRequestStatusEq;
  /**
   * 退货状态 比较(neq)
   */
  private String returnRequestStatusNeq;
  /**
   * 退货状态 比较(gt)
   */
  private String returnRequestStatusGt;
  /**
   * 退货状态 比较(gte)
   */
  private String returnRequestStatusGte;
  /**
   * 退货状态 比较(lt)
   */
  private String returnRequestStatusLt;
  /**
   * 退货状态 比较(lte)
   */
  private String returnRequestStatusLte;
  /**
   * 退货状态 比较(contains)
   */
  private String returnRequestStatusContains;
  /**
   * 退货状态 比较(notcontains)
   */
  private String returnRequestStatusNotcontains;
  /**
   * 退货状态 比较(startswith)
   */
  private String returnRequestStatusStartswith;
  /**
   * 退货状态 比较(endswith)
   */
  private String returnRequestStatusEndswith;
  /**
   * 退货状态 比较(isnull)
   */
  private Boolean returnRequestStatusIsnull;
  /**
   * 退货状态 比较(isnotnull)
   */
  private Boolean returnRequestStatusIsnotnull;

  /**
   * 退货状态(精确搜索)
   */
  private List<String> returnRequestStatusInList;

  /**
   * RMA单号(模糊搜索)
   */
  private String amazonRmaId;

  /**
   * RMA单号 比较(eq)
   */
  private String amazonRmaIdEq;
  /**
   * RMA单号 比较(neq)
   */
  private String amazonRmaIdNeq;
  /**
   * RMA单号 比较(gt)
   */
  private String amazonRmaIdGt;
  /**
   * RMA单号 比较(gte)
   */
  private String amazonRmaIdGte;
  /**
   * RMA单号 比较(lt)
   */
  private String amazonRmaIdLt;
  /**
   * RMA单号 比较(lte)
   */
  private String amazonRmaIdLte;
  /**
   * RMA单号 比较(contains)
   */
  private String amazonRmaIdContains;
  /**
   * RMA单号 比较(notcontains)
   */
  private String amazonRmaIdNotcontains;
  /**
   * RMA单号 比较(startswith)
   */
  private String amazonRmaIdStartswith;
  /**
   * RMA单号 比较(endswith)
   */
  private String amazonRmaIdEndswith;
  /**
   * RMA单号 比较(isnull)
   */
  private Boolean amazonRmaIdIsnull;
  /**
   * RMA单号 比较(isnotnull)
   */
  private Boolean amazonRmaIdIsnotnull;

  /**
   * RMA单号(精确搜索)
   */
  private List<String> amazonRmaIdInList;

  /**
   * 店铺RMA单号(模糊搜索)
   */
  private String merchantRmaId;

  /**
   * 店铺RMA单号 比较(eq)
   */
  private String merchantRmaIdEq;
  /**
   * 店铺RMA单号 比较(neq)
   */
  private String merchantRmaIdNeq;
  /**
   * 店铺RMA单号 比较(gt)
   */
  private String merchantRmaIdGt;
  /**
   * 店铺RMA单号 比较(gte)
   */
  private String merchantRmaIdGte;
  /**
   * 店铺RMA单号 比较(lt)
   */
  private String merchantRmaIdLt;
  /**
   * 店铺RMA单号 比较(lte)
   */
  private String merchantRmaIdLte;
  /**
   * 店铺RMA单号 比较(contains)
   */
  private String merchantRmaIdContains;
  /**
   * 店铺RMA单号 比较(notcontains)
   */
  private String merchantRmaIdNotcontains;
  /**
   * 店铺RMA单号 比较(startswith)
   */
  private String merchantRmaIdStartswith;
  /**
   * 店铺RMA单号 比较(endswith)
   */
  private String merchantRmaIdEndswith;
  /**
   * 店铺RMA单号 比较(isnull)
   */
  private Boolean merchantRmaIdIsnull;
  /**
   * 店铺RMA单号 比较(isnotnull)
   */
  private Boolean merchantRmaIdIsnotnull;

  /**
   * 店铺RMA单号(精确搜索)
   */
  private List<String> merchantRmaIdInList;

  /**
   * 标签类型(模糊搜索)
   */
  private String labelType;

  /**
   * 标签类型 比较(eq)
   */
  private String labelTypeEq;
  /**
   * 标签类型 比较(neq)
   */
  private String labelTypeNeq;
  /**
   * 标签类型 比较(gt)
   */
  private String labelTypeGt;
  /**
   * 标签类型 比较(gte)
   */
  private String labelTypeGte;
  /**
   * 标签类型 比较(lt)
   */
  private String labelTypeLt;
  /**
   * 标签类型 比较(lte)
   */
  private String labelTypeLte;
  /**
   * 标签类型 比较(contains)
   */
  private String labelTypeContains;
  /**
   * 标签类型 比较(notcontains)
   */
  private String labelTypeNotcontains;
  /**
   * 标签类型 比较(startswith)
   */
  private String labelTypeStartswith;
  /**
   * 标签类型 比较(endswith)
   */
  private String labelTypeEndswith;
  /**
   * 标签类型 比较(isnull)
   */
  private Boolean labelTypeIsnull;
  /**
   * 标签类型 比较(isnotnull)
   */
  private Boolean labelTypeIsnotnull;

  /**
   * 标签类型(精确搜索)
   */
  private List<String> labelTypeInList;

  /**
   * 标签费用
   */
  private java.math.BigDecimal labelCost;

  /**
   * 最小标签费用
   */
  private java.math.BigDecimal labelCostMin;

  /**
   * 最大标签费用
   */
  private java.math.BigDecimal labelCostMax;

  /**
   * 标签费用 比较(eq)
   */
  private java.math.BigDecimal labelCostEq;
  /**
   * 标签费用 比较(neq)
   */
  private java.math.BigDecimal labelCostNeq;
  /**
   * 标签费用 比较(gt)
   */
  private java.math.BigDecimal labelCostGt;
  /**
   * 标签费用 比较(gte)
   */
  private java.math.BigDecimal labelCostGte;
  /**
   * 标签费用 比较(lt)
   */
  private java.math.BigDecimal labelCostLt;
  /**
   * 标签费用 比较(lte)
   */
  private java.math.BigDecimal labelCostLte;
  /**
   * 标签费用 比较(contains)
   */
  private java.math.BigDecimal labelCostContains;
  /**
   * 标签费用 比较(notcontains)
   */
  private java.math.BigDecimal labelCostNotcontains;
  /**
   * 标签费用 比较(startswith)
   */
  private java.math.BigDecimal labelCostStartswith;
  /**
   * 标签费用 比较(endswith)
   */
  private java.math.BigDecimal labelCostEndswith;
  /**
   * 标签费用 比较(isnull)
   */
  private Boolean labelCostIsnull;
  /**
   * 标签费用 比较(isnotnull)
   */
  private Boolean labelCostIsnotnull;

  /**
   * 币种(模糊搜索)
   */
  private String currencyCode;

  /**
   * 币种 比较(eq)
   */
  private String currencyCodeEq;
  /**
   * 币种 比较(neq)
   */
  private String currencyCodeNeq;
  /**
   * 币种 比较(gt)
   */
  private String currencyCodeGt;
  /**
   * 币种 比较(gte)
   */
  private String currencyCodeGte;
  /**
   * 币种 比较(lt)
   */
  private String currencyCodeLt;
  /**
   * 币种 比较(lte)
   */
  private String currencyCodeLte;
  /**
   * 币种 比较(contains)
   */
  private String currencyCodeContains;
  /**
   * 币种 比较(notcontains)
   */
  private String currencyCodeNotcontains;
  /**
   * 币种 比较(startswith)
   */
  private String currencyCodeStartswith;
  /**
   * 币种 比较(endswith)
   */
  private String currencyCodeEndswith;
  /**
   * 币种 比较(isnull)
   */
  private Boolean currencyCodeIsnull;
  /**
   * 币种 比较(isnotnull)
   */
  private Boolean currencyCodeIsnotnull;

  /**
   * 币种(精确搜索)
   */
  private List<String> currencyCodeInList;

  /**
   * 承运商(模糊搜索)
   */
  private String returnCarrier;

  /**
   * 承运商 比较(eq)
   */
  private String returnCarrierEq;
  /**
   * 承运商 比较(neq)
   */
  private String returnCarrierNeq;
  /**
   * 承运商 比较(gt)
   */
  private String returnCarrierGt;
  /**
   * 承运商 比较(gte)
   */
  private String returnCarrierGte;
  /**
   * 承运商 比较(lt)
   */
  private String returnCarrierLt;
  /**
   * 承运商 比较(lte)
   */
  private String returnCarrierLte;
  /**
   * 承运商 比较(contains)
   */
  private String returnCarrierContains;
  /**
   * 承运商 比较(notcontains)
   */
  private String returnCarrierNotcontains;
  /**
   * 承运商 比较(startswith)
   */
  private String returnCarrierStartswith;
  /**
   * 承运商 比较(endswith)
   */
  private String returnCarrierEndswith;
  /**
   * 承运商 比较(isnull)
   */
  private Boolean returnCarrierIsnull;
  /**
   * 承运商 比较(isnotnull)
   */
  private Boolean returnCarrierIsnotnull;

  /**
   * 承运商(精确搜索)
   */
  private List<String> returnCarrierInList;

  /**
   * 运单号(模糊搜索)
   */
  private String trackingId;

  /**
   * 运单号 比较(eq)
   */
  private String trackingIdEq;
  /**
   * 运单号 比较(neq)
   */
  private String trackingIdNeq;
  /**
   * 运单号 比较(gt)
   */
  private String trackingIdGt;
  /**
   * 运单号 比较(gte)
   */
  private String trackingIdGte;
  /**
   * 运单号 比较(lt)
   */
  private String trackingIdLt;
  /**
   * 运单号 比较(lte)
   */
  private String trackingIdLte;
  /**
   * 运单号 比较(contains)
   */
  private String trackingIdContains;
  /**
   * 运单号 比较(notcontains)
   */
  private String trackingIdNotcontains;
  /**
   * 运单号 比较(startswith)
   */
  private String trackingIdStartswith;
  /**
   * 运单号 比较(endswith)
   */
  private String trackingIdEndswith;
  /**
   * 运单号 比较(isnull)
   */
  private Boolean trackingIdIsnull;
  /**
   * 运单号 比较(isnotnull)
   */
  private Boolean trackingIdIsnotnull;

  /**
   * 运单号(精确搜索)
   */
  private List<String> trackingIdInList;

  /**
   * 标签支付方(模糊搜索)
   */
  private String labelToBePaidBy;

  /**
   * 标签支付方 比较(eq)
   */
  private String labelToBePaidByEq;
  /**
   * 标签支付方 比较(neq)
   */
  private String labelToBePaidByNeq;
  /**
   * 标签支付方 比较(gt)
   */
  private String labelToBePaidByGt;
  /**
   * 标签支付方 比较(gte)
   */
  private String labelToBePaidByGte;
  /**
   * 标签支付方 比较(lt)
   */
  private String labelToBePaidByLt;
  /**
   * 标签支付方 比较(lte)
   */
  private String labelToBePaidByLte;
  /**
   * 标签支付方 比较(contains)
   */
  private String labelToBePaidByContains;
  /**
   * 标签支付方 比较(notcontains)
   */
  private String labelToBePaidByNotcontains;
  /**
   * 标签支付方 比较(startswith)
   */
  private String labelToBePaidByStartswith;
  /**
   * 标签支付方 比较(endswith)
   */
  private String labelToBePaidByEndswith;
  /**
   * 标签支付方 比较(isnull)
   */
  private Boolean labelToBePaidByIsnull;
  /**
   * 标签支付方 比较(isnotnull)
   */
  private Boolean labelToBePaidByIsnotnull;

  /**
   * 标签支付方(精确搜索)
   */
  private List<String> labelToBePaidByInList;

  /**
   * A-to-Z标签, N代表否，Y代表是(模糊搜索)
   */
  private String aToZClaim;

  /**
   * A-to-Z标签, N代表否，Y代表是 比较(eq)
   */
  private String aToZClaimEq;
  /**
   * A-to-Z标签, N代表否，Y代表是 比较(neq)
   */
  private String aToZClaimNeq;
  /**
   * A-to-Z标签, N代表否，Y代表是 比较(gt)
   */
  private String aToZClaimGt;
  /**
   * A-to-Z标签, N代表否，Y代表是 比较(gte)
   */
  private String aToZClaimGte;
  /**
   * A-to-Z标签, N代表否，Y代表是 比较(lt)
   */
  private String aToZClaimLt;
  /**
   * A-to-Z标签, N代表否，Y代表是 比较(lte)
   */
  private String aToZClaimLte;
  /**
   * A-to-Z标签, N代表否，Y代表是 比较(contains)
   */
  private String aToZClaimContains;
  /**
   * A-to-Z标签, N代表否，Y代表是 比较(notcontains)
   */
  private String aToZClaimNotcontains;
  /**
   * A-to-Z标签, N代表否，Y代表是 比较(startswith)
   */
  private String aToZClaimStartswith;
  /**
   * A-to-Z标签, N代表否，Y代表是 比较(endswith)
   */
  private String aToZClaimEndswith;
  /**
   * A-to-Z标签, N代表否，Y代表是 比较(isnull)
   */
  private Boolean aToZClaimIsnull;
  /**
   * A-to-Z标签, N代表否，Y代表是 比较(isnotnull)
   */
  private Boolean aToZClaimIsnotnull;

  /**
   * A-to-Z标签, N代表否，Y代表是(精确搜索)
   */
  private List<String> aToZClaimInList;

  /**
   * Prime标签, N代表否，Y代表是(模糊搜索)
   */
  private String isPrime;

  /**
   * Prime标签, N代表否，Y代表是 比较(eq)
   */
  private String isPrimeEq;
  /**
   * Prime标签, N代表否，Y代表是 比较(neq)
   */
  private String isPrimeNeq;
  /**
   * Prime标签, N代表否，Y代表是 比较(gt)
   */
  private String isPrimeGt;
  /**
   * Prime标签, N代表否，Y代表是 比较(gte)
   */
  private String isPrimeGte;
  /**
   * Prime标签, N代表否，Y代表是 比较(lt)
   */
  private String isPrimeLt;
  /**
   * Prime标签, N代表否，Y代表是 比较(lte)
   */
  private String isPrimeLte;
  /**
   * Prime标签, N代表否，Y代表是 比较(contains)
   */
  private String isPrimeContains;
  /**
   * Prime标签, N代表否，Y代表是 比较(notcontains)
   */
  private String isPrimeNotcontains;
  /**
   * Prime标签, N代表否，Y代表是 比较(startswith)
   */
  private String isPrimeStartswith;
  /**
   * Prime标签, N代表否，Y代表是 比较(endswith)
   */
  private String isPrimeEndswith;
  /**
   * Prime标签, N代表否，Y代表是 比较(isnull)
   */
  private Boolean isPrimeIsnull;
  /**
   * Prime标签, N代表否，Y代表是 比较(isnotnull)
   */
  private Boolean isPrimeIsnotnull;

  /**
   * Prime标签, N代表否，Y代表是(精确搜索)
   */
  private List<String> isPrimeInList;

  /**
   * ASIN(模糊搜索)
   */
  private String asin;

  /**
   * ASIN 比较(eq)
   */
  private String asinEq;
  /**
   * ASIN 比较(neq)
   */
  private String asinNeq;
  /**
   * ASIN 比较(gt)
   */
  private String asinGt;
  /**
   * ASIN 比较(gte)
   */
  private String asinGte;
  /**
   * ASIN 比较(lt)
   */
  private String asinLt;
  /**
   * ASIN 比较(lte)
   */
  private String asinLte;
  /**
   * ASIN 比较(contains)
   */
  private String asinContains;
  /**
   * ASIN 比较(notcontains)
   */
  private String asinNotcontains;
  /**
   * ASIN 比较(startswith)
   */
  private String asinStartswith;
  /**
   * ASIN 比较(endswith)
   */
  private String asinEndswith;
  /**
   * ASIN 比较(isnull)
   */
  private Boolean asinIsnull;
  /**
   * ASIN 比较(isnotnull)
   */
  private Boolean asinIsnotnull;

  /**
   * ASIN(精确搜索)
   */
  private List<String> asinInList;

  /**
   * MSKU(模糊搜索)
   */
  private String merchantSku;

  /**
   * MSKU 比较(eq)
   */
  private String merchantSkuEq;
  /**
   * MSKU 比较(neq)
   */
  private String merchantSkuNeq;
  /**
   * MSKU 比较(gt)
   */
  private String merchantSkuGt;
  /**
   * MSKU 比较(gte)
   */
  private String merchantSkuGte;
  /**
   * MSKU 比较(lt)
   */
  private String merchantSkuLt;
  /**
   * MSKU 比较(lte)
   */
  private String merchantSkuLte;
  /**
   * MSKU 比较(contains)
   */
  private String merchantSkuContains;
  /**
   * MSKU 比较(notcontains)
   */
  private String merchantSkuNotcontains;
  /**
   * MSKU 比较(startswith)
   */
  private String merchantSkuStartswith;
  /**
   * MSKU 比较(endswith)
   */
  private String merchantSkuEndswith;
  /**
   * MSKU 比较(isnull)
   */
  private Boolean merchantSkuIsnull;
  /**
   * MSKU 比较(isnotnull)
   */
  private Boolean merchantSkuIsnotnull;

  /**
   * MSKU(精确搜索)
   */
  private List<String> merchantSkuInList;

  /**
   * 标题(模糊搜索)
   */
  private String itemName;

  /**
   * 标题 比较(eq)
   */
  private String itemNameEq;
  /**
   * 标题 比较(neq)
   */
  private String itemNameNeq;
  /**
   * 标题 比较(gt)
   */
  private String itemNameGt;
  /**
   * 标题 比较(gte)
   */
  private String itemNameGte;
  /**
   * 标题 比较(lt)
   */
  private String itemNameLt;
  /**
   * 标题 比较(lte)
   */
  private String itemNameLte;
  /**
   * 标题 比较(contains)
   */
  private String itemNameContains;
  /**
   * 标题 比较(notcontains)
   */
  private String itemNameNotcontains;
  /**
   * 标题 比较(startswith)
   */
  private String itemNameStartswith;
  /**
   * 标题 比较(endswith)
   */
  private String itemNameEndswith;
  /**
   * 标题 比较(isnull)
   */
  private Boolean itemNameIsnull;
  /**
   * 标题 比较(isnotnull)
   */
  private Boolean itemNameIsnotnull;

  /**
   * 退货数量
   */
  private Integer returnQuantity;

  /**
   * 最小退货数量
   */
  private Integer returnQuantityMin;

  /**
   * 最大退货数量
   */
  private Integer returnQuantityMax;

  /**
   * 退货数量 比较(eq)
   */
  private Integer returnQuantityEq;
  /**
   * 退货数量 比较(neq)
   */
  private Integer returnQuantityNeq;
  /**
   * 退货数量 比较(gt)
   */
  private Integer returnQuantityGt;
  /**
   * 退货数量 比较(gte)
   */
  private Integer returnQuantityGte;
  /**
   * 退货数量 比较(lt)
   */
  private Integer returnQuantityLt;
  /**
   * 退货数量 比较(lte)
   */
  private Integer returnQuantityLte;
  /**
   * 退货数量 比较(contains)
   */
  private Integer returnQuantityContains;
  /**
   * 退货数量 比较(notcontains)
   */
  private Integer returnQuantityNotcontains;
  /**
   * 退货数量 比较(startswith)
   */
  private Integer returnQuantityStartswith;
  /**
   * 退货数量 比较(endswith)
   */
  private Integer returnQuantityEndswith;
  /**
   * 退货数量 比较(isnull)
   */
  private Boolean returnQuantityIsnull;
  /**
   * 退货数量 比较(isnotnull)
   */
  private Boolean returnQuantityIsnotnull;

  /**
   * 退货原因(模糊搜索)
   */
  private String returnReason;

  /**
   * 退货原因 比较(eq)
   */
  private String returnReasonEq;
  /**
   * 退货原因 比较(neq)
   */
  private String returnReasonNeq;
  /**
   * 退货原因 比较(gt)
   */
  private String returnReasonGt;
  /**
   * 退货原因 比较(gte)
   */
  private String returnReasonGte;
  /**
   * 退货原因 比较(lt)
   */
  private String returnReasonLt;
  /**
   * 退货原因 比较(lte)
   */
  private String returnReasonLte;
  /**
   * 退货原因 比较(contains)
   */
  private String returnReasonContains;
  /**
   * 退货原因 比较(notcontains)
   */
  private String returnReasonNotcontains;
  /**
   * 退货原因 比较(startswith)
   */
  private String returnReasonStartswith;
  /**
   * 退货原因 比较(endswith)
   */
  private String returnReasonEndswith;
  /**
   * 退货原因 比较(isnull)
   */
  private Boolean returnReasonIsnull;
  /**
   * 退货原因 比较(isnotnull)
   */
  private Boolean returnReasonIsnotnull;

  /**
   * 退货原因(精确搜索)
   */
  private List<String> returnReasonInList;

  /**
   * 是否符合政策：N代表否，Y代表是(模糊搜索)
   */
  private String inPolicy;

  /**
   * 是否符合政策：N代表否，Y代表是 比较(eq)
   */
  private String inPolicyEq;
  /**
   * 是否符合政策：N代表否，Y代表是 比较(neq)
   */
  private String inPolicyNeq;
  /**
   * 是否符合政策：N代表否，Y代表是 比较(gt)
   */
  private String inPolicyGt;
  /**
   * 是否符合政策：N代表否，Y代表是 比较(gte)
   */
  private String inPolicyGte;
  /**
   * 是否符合政策：N代表否，Y代表是 比较(lt)
   */
  private String inPolicyLt;
  /**
   * 是否符合政策：N代表否，Y代表是 比较(lte)
   */
  private String inPolicyLte;
  /**
   * 是否符合政策：N代表否，Y代表是 比较(contains)
   */
  private String inPolicyContains;
  /**
   * 是否符合政策：N代表否，Y代表是 比较(notcontains)
   */
  private String inPolicyNotcontains;
  /**
   * 是否符合政策：N代表否，Y代表是 比较(startswith)
   */
  private String inPolicyStartswith;
  /**
   * 是否符合政策：N代表否，Y代表是 比较(endswith)
   */
  private String inPolicyEndswith;
  /**
   * 是否符合政策：N代表否，Y代表是 比较(isnull)
   */
  private Boolean inPolicyIsnull;
  /**
   * 是否符合政策：N代表否，Y代表是 比较(isnotnull)
   */
  private Boolean inPolicyIsnotnull;

  /**
   * 是否符合政策：N代表否，Y代表是(精确搜索)
   */
  private List<String> inPolicyInList;

  /**
   * 退货类型(模糊搜索)
   */
  private String returnType;

  /**
   * 退货类型 比较(eq)
   */
  private String returnTypeEq;
  /**
   * 退货类型 比较(neq)
   */
  private String returnTypeNeq;
  /**
   * 退货类型 比较(gt)
   */
  private String returnTypeGt;
  /**
   * 退货类型 比较(gte)
   */
  private String returnTypeGte;
  /**
   * 退货类型 比较(lt)
   */
  private String returnTypeLt;
  /**
   * 退货类型 比较(lte)
   */
  private String returnTypeLte;
  /**
   * 退货类型 比较(contains)
   */
  private String returnTypeContains;
  /**
   * 退货类型 比较(notcontains)
   */
  private String returnTypeNotcontains;
  /**
   * 退货类型 比较(startswith)
   */
  private String returnTypeStartswith;
  /**
   * 退货类型 比较(endswith)
   */
  private String returnTypeEndswith;
  /**
   * 退货类型 比较(isnull)
   */
  private Boolean returnTypeIsnull;
  /**
   * 退货类型 比较(isnotnull)
   */
  private Boolean returnTypeIsnotnull;

  /**
   * 退货类型(精确搜索)
   */
  private List<String> returnTypeInList;

  /**
   * 解决方法(模糊搜索)
   */
  private String resolution;

  /**
   * 解决方法 比较(eq)
   */
  private String resolutionEq;
  /**
   * 解决方法 比较(neq)
   */
  private String resolutionNeq;
  /**
   * 解决方法 比较(gt)
   */
  private String resolutionGt;
  /**
   * 解决方法 比较(gte)
   */
  private String resolutionGte;
  /**
   * 解决方法 比较(lt)
   */
  private String resolutionLt;
  /**
   * 解决方法 比较(lte)
   */
  private String resolutionLte;
  /**
   * 解决方法 比较(contains)
   */
  private String resolutionContains;
  /**
   * 解决方法 比较(notcontains)
   */
  private String resolutionNotcontains;
  /**
   * 解决方法 比较(startswith)
   */
  private String resolutionStartswith;
  /**
   * 解决方法 比较(endswith)
   */
  private String resolutionEndswith;
  /**
   * 解决方法 比较(isnull)
   */
  private Boolean resolutionIsnull;
  /**
   * 解决方法 比较(isnotnull)
   */
  private Boolean resolutionIsnotnull;

  /**
   * 解决方法(精确搜索)
   */
  private List<String> resolutionInList;

  /**
   * 发票号码(模糊搜索)
   */
  private String invoiceNumber;

  /**
   * 发票号码 比较(eq)
   */
  private String invoiceNumberEq;
  /**
   * 发票号码 比较(neq)
   */
  private String invoiceNumberNeq;
  /**
   * 发票号码 比较(gt)
   */
  private String invoiceNumberGt;
  /**
   * 发票号码 比较(gte)
   */
  private String invoiceNumberGte;
  /**
   * 发票号码 比较(lt)
   */
  private String invoiceNumberLt;
  /**
   * 发票号码 比较(lte)
   */
  private String invoiceNumberLte;
  /**
   * 发票号码 比较(contains)
   */
  private String invoiceNumberContains;
  /**
   * 发票号码 比较(notcontains)
   */
  private String invoiceNumberNotcontains;
  /**
   * 发票号码 比较(startswith)
   */
  private String invoiceNumberStartswith;
  /**
   * 发票号码 比较(endswith)
   */
  private String invoiceNumberEndswith;
  /**
   * 发票号码 比较(isnull)
   */
  private Boolean invoiceNumberIsnull;
  /**
   * 发票号码 比较(isnotnull)
   */
  private Boolean invoiceNumberIsnotnull;

  /**
   * 发票号码(精确搜索)
   */
  private List<String> invoiceNumberInList;

  /**
   * 最早退货送达日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date returnDeliveryDateStart;

  /**
   * 最晚退货送达日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date returnDeliveryDateEnd;

  /**
   * 退货送达日期 比较(eq)
   */
  private Date returnDeliveryDateEq;
  /**
   * 退货送达日期 比较(neq)
   */
  private Date returnDeliveryDateNeq;
  /**
   * 退货送达日期 比较(gt)
   */
  private Date returnDeliveryDateGt;
  /**
   * 退货送达日期 比较(gte)
   */
  private Date returnDeliveryDateGte;
  /**
   * 退货送达日期 比较(lt)
   */
  private Date returnDeliveryDateLt;
  /**
   * 退货送达日期 比较(lte)
   */
  private Date returnDeliveryDateLte;
  /**
   * 退货送达日期 比较(contains)
   */
  private Date returnDeliveryDateContains;
  /**
   * 退货送达日期 比较(notcontains)
   */
  private Date returnDeliveryDateNotcontains;
  /**
   * 退货送达日期 比较(startswith)
   */
  private Date returnDeliveryDateStartswith;
  /**
   * 退货送达日期 比较(endswith)
   */
  private Date returnDeliveryDateEndswith;
  /**
   * 退货送达日期 比较(isnull)
   */
  private Boolean returnDeliveryDateIsnull;
  /**
   * 退货送达日期 比较(isnotnull)
   */
  private Boolean returnDeliveryDateIsnotnull;

  /**
   * 订单金额
   */
  private java.math.BigDecimal orderAmount;

  /**
   * 最小订单金额
   */
  private java.math.BigDecimal orderAmountMin;

  /**
   * 最大订单金额
   */
  private java.math.BigDecimal orderAmountMax;

  /**
   * 订单金额 比较(eq)
   */
  private java.math.BigDecimal orderAmountEq;
  /**
   * 订单金额 比较(neq)
   */
  private java.math.BigDecimal orderAmountNeq;
  /**
   * 订单金额 比较(gt)
   */
  private java.math.BigDecimal orderAmountGt;
  /**
   * 订单金额 比较(gte)
   */
  private java.math.BigDecimal orderAmountGte;
  /**
   * 订单金额 比较(lt)
   */
  private java.math.BigDecimal orderAmountLt;
  /**
   * 订单金额 比较(lte)
   */
  private java.math.BigDecimal orderAmountLte;
  /**
   * 订单金额 比较(contains)
   */
  private java.math.BigDecimal orderAmountContains;
  /**
   * 订单金额 比较(notcontains)
   */
  private java.math.BigDecimal orderAmountNotcontains;
  /**
   * 订单金额 比较(startswith)
   */
  private java.math.BigDecimal orderAmountStartswith;
  /**
   * 订单金额 比较(endswith)
   */
  private java.math.BigDecimal orderAmountEndswith;
  /**
   * 订单金额 比较(isnull)
   */
  private Boolean orderAmountIsnull;
  /**
   * 订单金额 比较(isnotnull)
   */
  private Boolean orderAmountIsnotnull;

  /**
   * 商品信息--原始数量
   */
  private Integer orderQuantity;

  /**
   * 最小商品信息--原始数量
   */
  private Integer orderQuantityMin;

  /**
   * 最大商品信息--原始数量
   */
  private Integer orderQuantityMax;

  /**
   * 商品信息--原始数量 比较(eq)
   */
  private Integer orderQuantityEq;
  /**
   * 商品信息--原始数量 比较(neq)
   */
  private Integer orderQuantityNeq;
  /**
   * 商品信息--原始数量 比较(gt)
   */
  private Integer orderQuantityGt;
  /**
   * 商品信息--原始数量 比较(gte)
   */
  private Integer orderQuantityGte;
  /**
   * 商品信息--原始数量 比较(lt)
   */
  private Integer orderQuantityLt;
  /**
   * 商品信息--原始数量 比较(lte)
   */
  private Integer orderQuantityLte;
  /**
   * 商品信息--原始数量 比较(contains)
   */
  private Integer orderQuantityContains;
  /**
   * 商品信息--原始数量 比较(notcontains)
   */
  private Integer orderQuantityNotcontains;
  /**
   * 商品信息--原始数量 比较(startswith)
   */
  private Integer orderQuantityStartswith;
  /**
   * 商品信息--原始数量 比较(endswith)
   */
  private Integer orderQuantityEndswith;
  /**
   * 商品信息--原始数量 比较(isnull)
   */
  private Boolean orderQuantityIsnull;
  /**
   * 商品信息--原始数量 比较(isnotnull)
   */
  private Boolean orderQuantityIsnotnull;

  /**
   * Safe-T索赔原因(模糊搜索)
   */
  private String safeTActionReason;

  /**
   * Safe-T索赔原因 比较(eq)
   */
  private String safeTActionReasonEq;
  /**
   * Safe-T索赔原因 比较(neq)
   */
  private String safeTActionReasonNeq;
  /**
   * Safe-T索赔原因 比较(gt)
   */
  private String safeTActionReasonGt;
  /**
   * Safe-T索赔原因 比较(gte)
   */
  private String safeTActionReasonGte;
  /**
   * Safe-T索赔原因 比较(lt)
   */
  private String safeTActionReasonLt;
  /**
   * Safe-T索赔原因 比较(lte)
   */
  private String safeTActionReasonLte;
  /**
   * Safe-T索赔原因 比较(contains)
   */
  private String safeTActionReasonContains;
  /**
   * Safe-T索赔原因 比较(notcontains)
   */
  private String safeTActionReasonNotcontains;
  /**
   * Safe-T索赔原因 比较(startswith)
   */
  private String safeTActionReasonStartswith;
  /**
   * Safe-T索赔原因 比较(endswith)
   */
  private String safeTActionReasonEndswith;
  /**
   * Safe-T索赔原因 比较(isnull)
   */
  private Boolean safeTActionReasonIsnull;
  /**
   * Safe-T索赔原因 比较(isnotnull)
   */
  private Boolean safeTActionReasonIsnotnull;

  /**
   * Safe-T索赔原因(精确搜索)
   */
  private List<String> safeTActionReasonInList;

  /**
   * Saft-T索赔单号(模糊搜索)
   */
  private String safeTClaimId;

  /**
   * Saft-T索赔单号 比较(eq)
   */
  private String safeTClaimIdEq;
  /**
   * Saft-T索赔单号 比较(neq)
   */
  private String safeTClaimIdNeq;
  /**
   * Saft-T索赔单号 比较(gt)
   */
  private String safeTClaimIdGt;
  /**
   * Saft-T索赔单号 比较(gte)
   */
  private String safeTClaimIdGte;
  /**
   * Saft-T索赔单号 比较(lt)
   */
  private String safeTClaimIdLt;
  /**
   * Saft-T索赔单号 比较(lte)
   */
  private String safeTClaimIdLte;
  /**
   * Saft-T索赔单号 比较(contains)
   */
  private String safeTClaimIdContains;
  /**
   * Saft-T索赔单号 比较(notcontains)
   */
  private String safeTClaimIdNotcontains;
  /**
   * Saft-T索赔单号 比较(startswith)
   */
  private String safeTClaimIdStartswith;
  /**
   * Saft-T索赔单号 比较(endswith)
   */
  private String safeTClaimIdEndswith;
  /**
   * Saft-T索赔单号 比较(isnull)
   */
  private Boolean safeTClaimIdIsnull;
  /**
   * Saft-T索赔单号 比较(isnotnull)
   */
  private Boolean safeTClaimIdIsnotnull;

  /**
   * Saft-T索赔单号(精确搜索)
   */
  private List<String> safeTClaimIdInList;

  /**
   * Saft-T索赔状态(模糊搜索)
   */
  private String safeTClaimState;

  /**
   * Saft-T索赔状态 比较(eq)
   */
  private String safeTClaimStateEq;
  /**
   * Saft-T索赔状态 比较(neq)
   */
  private String safeTClaimStateNeq;
  /**
   * Saft-T索赔状态 比较(gt)
   */
  private String safeTClaimStateGt;
  /**
   * Saft-T索赔状态 比较(gte)
   */
  private String safeTClaimStateGte;
  /**
   * Saft-T索赔状态 比较(lt)
   */
  private String safeTClaimStateLt;
  /**
   * Saft-T索赔状态 比较(lte)
   */
  private String safeTClaimStateLte;
  /**
   * Saft-T索赔状态 比较(contains)
   */
  private String safeTClaimStateContains;
  /**
   * Saft-T索赔状态 比较(notcontains)
   */
  private String safeTClaimStateNotcontains;
  /**
   * Saft-T索赔状态 比较(startswith)
   */
  private String safeTClaimStateStartswith;
  /**
   * Saft-T索赔状态 比较(endswith)
   */
  private String safeTClaimStateEndswith;
  /**
   * Saft-T索赔状态 比较(isnull)
   */
  private Boolean safeTClaimStateIsnull;
  /**
   * Saft-T索赔状态 比较(isnotnull)
   */
  private Boolean safeTClaimStateIsnotnull;

  /**
   * Saft-T索赔状态(精确搜索)
   */
  private List<String> safeTClaimStateInList;

  /**
   * 最早Saft-T索赔时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date safeTClaimCreationTimeStart;

  /**
   * 最晚Saft-T索赔时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date safeTClaimCreationTimeEnd;

  /**
   * Saft-T索赔时间 比较(eq)
   */
  private Date safeTClaimCreationTimeEq;
  /**
   * Saft-T索赔时间 比较(neq)
   */
  private Date safeTClaimCreationTimeNeq;
  /**
   * Saft-T索赔时间 比较(gt)
   */
  private Date safeTClaimCreationTimeGt;
  /**
   * Saft-T索赔时间 比较(gte)
   */
  private Date safeTClaimCreationTimeGte;
  /**
   * Saft-T索赔时间 比较(lt)
   */
  private Date safeTClaimCreationTimeLt;
  /**
   * Saft-T索赔时间 比较(lte)
   */
  private Date safeTClaimCreationTimeLte;
  /**
   * Saft-T索赔时间 比较(contains)
   */
  private Date safeTClaimCreationTimeContains;
  /**
   * Saft-T索赔时间 比较(notcontains)
   */
  private Date safeTClaimCreationTimeNotcontains;
  /**
   * Saft-T索赔时间 比较(startswith)
   */
  private Date safeTClaimCreationTimeStartswith;
  /**
   * Saft-T索赔时间 比较(endswith)
   */
  private Date safeTClaimCreationTimeEndswith;
  /**
   * Saft-T索赔时间 比较(isnull)
   */
  private Boolean safeTClaimCreationTimeIsnull;
  /**
   * Saft-T索赔时间 比较(isnotnull)
   */
  private Boolean safeTClaimCreationTimeIsnotnull;

  /**
   * Safe-T索赔金额
   */
  private java.math.BigDecimal safeTClaimReimbursementAmount;

  /**
   * 最小Safe-T索赔金额
   */
  private java.math.BigDecimal safeTClaimReimbursementAmountMin;

  /**
   * 最大Safe-T索赔金额
   */
  private java.math.BigDecimal safeTClaimReimbursementAmountMax;

  /**
   * Safe-T索赔金额 比较(eq)
   */
  private java.math.BigDecimal safeTClaimReimbursementAmountEq;
  /**
   * Safe-T索赔金额 比较(neq)
   */
  private java.math.BigDecimal safeTClaimReimbursementAmountNeq;
  /**
   * Safe-T索赔金额 比较(gt)
   */
  private java.math.BigDecimal safeTClaimReimbursementAmountGt;
  /**
   * Safe-T索赔金额 比较(gte)
   */
  private java.math.BigDecimal safeTClaimReimbursementAmountGte;
  /**
   * Safe-T索赔金额 比较(lt)
   */
  private java.math.BigDecimal safeTClaimReimbursementAmountLt;
  /**
   * Safe-T索赔金额 比较(lte)
   */
  private java.math.BigDecimal safeTClaimReimbursementAmountLte;
  /**
   * Safe-T索赔金额 比较(contains)
   */
  private java.math.BigDecimal safeTClaimReimbursementAmountContains;
  /**
   * Safe-T索赔金额 比较(notcontains)
   */
  private java.math.BigDecimal safeTClaimReimbursementAmountNotcontains;
  /**
   * Safe-T索赔金额 比较(startswith)
   */
  private java.math.BigDecimal safeTClaimReimbursementAmountStartswith;
  /**
   * Safe-T索赔金额 比较(endswith)
   */
  private java.math.BigDecimal safeTClaimReimbursementAmountEndswith;
  /**
   * Safe-T索赔金额 比较(isnull)
   */
  private Boolean safeTClaimReimbursementAmountIsnull;
  /**
   * Safe-T索赔金额 比较(isnotnull)
   */
  private Boolean safeTClaimReimbursementAmountIsnotnull;

  /**
   * 退款金额
   */
  private java.math.BigDecimal refundedAmount;

  /**
   * 最小退款金额
   */
  private java.math.BigDecimal refundedAmountMin;

  /**
   * 最大退款金额
   */
  private java.math.BigDecimal refundedAmountMax;

  /**
   * 退款金额 比较(eq)
   */
  private java.math.BigDecimal refundedAmountEq;
  /**
   * 退款金额 比较(neq)
   */
  private java.math.BigDecimal refundedAmountNeq;
  /**
   * 退款金额 比较(gt)
   */
  private java.math.BigDecimal refundedAmountGt;
  /**
   * 退款金额 比较(gte)
   */
  private java.math.BigDecimal refundedAmountGte;
  /**
   * 退款金额 比较(lt)
   */
  private java.math.BigDecimal refundedAmountLt;
  /**
   * 退款金额 比较(lte)
   */
  private java.math.BigDecimal refundedAmountLte;
  /**
   * 退款金额 比较(contains)
   */
  private java.math.BigDecimal refundedAmountContains;
  /**
   * 退款金额 比较(notcontains)
   */
  private java.math.BigDecimal refundedAmountNotcontains;
  /**
   * 退款金额 比较(startswith)
   */
  private java.math.BigDecimal refundedAmountStartswith;
  /**
   * 退款金额 比较(endswith)
   */
  private java.math.BigDecimal refundedAmountEndswith;
  /**
   * 退款金额 比较(isnull)
   */
  private Boolean refundedAmountIsnull;
  /**
   * 退款金额 比较(isnotnull)
   */
  private Boolean refundedAmountIsnotnull;

  /**
   * 店铺id
   */
  private Long sid;

  /**
   * 最小店铺id
   */
  private Long sidMin;

  /**
   * 最大店铺id
   */
  private Long sidMax;

  /**
   * 店铺id 比较(eq)
   */
  private Long sidEq;
  /**
   * 店铺id 比较(neq)
   */
  private Long sidNeq;
  /**
   * 店铺id 比较(gt)
   */
  private Long sidGt;
  /**
   * 店铺id 比较(gte)
   */
  private Long sidGte;
  /**
   * 店铺id 比较(lt)
   */
  private Long sidLt;
  /**
   * 店铺id 比较(lte)
   */
  private Long sidLte;
  /**
   * 店铺id 比较(contains)
   */
  private Long sidContains;
  /**
   * 店铺id 比较(notcontains)
   */
  private Long sidNotcontains;
  /**
   * 店铺id 比较(startswith)
   */
  private Long sidStartswith;
  /**
   * 店铺id 比较(endswith)
   */
  private Long sidEndswith;
  /**
   * 店铺id 比较(isnull)
   */
  private Boolean sidIsnull;
  /**
   * 店铺id 比较(isnotnull)
   */
  private Boolean sidIsnotnull;

  /**
   * 站点(模糊搜索)
   */
  private String region;

  /**
   * 站点 比较(eq)
   */
  private String regionEq;
  /**
   * 站点 比较(neq)
   */
  private String regionNeq;
  /**
   * 站点 比较(gt)
   */
  private String regionGt;
  /**
   * 站点 比较(gte)
   */
  private String regionGte;
  /**
   * 站点 比较(lt)
   */
  private String regionLt;
  /**
   * 站点 比较(lte)
   */
  private String regionLte;
  /**
   * 站点 比较(contains)
   */
  private String regionContains;
  /**
   * 站点 比较(notcontains)
   */
  private String regionNotcontains;
  /**
   * 站点 比较(startswith)
   */
  private String regionStartswith;
  /**
   * 站点 比较(endswith)
   */
  private String regionEndswith;
  /**
   * 站点 比较(isnull)
   */
  private Boolean regionIsnull;
  /**
   * 站点 比较(isnotnull)
   */
  private Boolean regionIsnotnull;

  /**
   * 站点(精确搜索)
   */
  private List<String> regionInList;

  /**
   * 品名(模糊搜索)
   */
  private String name;

  /**
   * 品名 比较(eq)
   */
  private String nameEq;
  /**
   * 品名 比较(neq)
   */
  private String nameNeq;
  /**
   * 品名 比较(gt)
   */
  private String nameGt;
  /**
   * 品名 比较(gte)
   */
  private String nameGte;
  /**
   * 品名 比较(lt)
   */
  private String nameLt;
  /**
   * 品名 比较(lte)
   */
  private String nameLte;
  /**
   * 品名 比较(contains)
   */
  private String nameContains;
  /**
   * 品名 比较(notcontains)
   */
  private String nameNotcontains;
  /**
   * 品名 比较(startswith)
   */
  private String nameStartswith;
  /**
   * 品名 比较(endswith)
   */
  private String nameEndswith;
  /**
   * 品名 比较(isnull)
   */
  private Boolean nameIsnull;
  /**
   * 品名 比较(isnotnull)
   */
  private Boolean nameIsnotnull;

  /**
   * 品名(精确搜索)
   */
  private List<String> nameInList;

  /**
   * 商品标题(模糊搜索)
   */
  private String productName;

  /**
   * 商品标题 比较(eq)
   */
  private String productNameEq;
  /**
   * 商品标题 比较(neq)
   */
  private String productNameNeq;
  /**
   * 商品标题 比较(gt)
   */
  private String productNameGt;
  /**
   * 商品标题 比较(gte)
   */
  private String productNameGte;
  /**
   * 商品标题 比较(lt)
   */
  private String productNameLt;
  /**
   * 商品标题 比较(lte)
   */
  private String productNameLte;
  /**
   * 商品标题 比较(contains)
   */
  private String productNameContains;
  /**
   * 商品标题 比较(notcontains)
   */
  private String productNameNotcontains;
  /**
   * 商品标题 比较(startswith)
   */
  private String productNameStartswith;
  /**
   * 商品标题 比较(endswith)
   */
  private String productNameEndswith;
  /**
   * 商品标题 比较(isnull)
   */
  private Boolean productNameIsnull;
  /**
   * 商品标题 比较(isnotnull)
   */
  private Boolean productNameIsnotnull;

  /**
   * 商品标题(精确搜索)
   */
  private List<String> productNameInList;

  /**
   * sku(模糊搜索)
   */
  private String sku;

  /**
   * sku 比较(eq)
   */
  private String skuEq;
  /**
   * sku 比较(neq)
   */
  private String skuNeq;
  /**
   * sku 比较(gt)
   */
  private String skuGt;
  /**
   * sku 比较(gte)
   */
  private String skuGte;
  /**
   * sku 比较(lt)
   */
  private String skuLt;
  /**
   * sku 比较(lte)
   */
  private String skuLte;
  /**
   * sku 比较(contains)
   */
  private String skuContains;
  /**
   * sku 比较(notcontains)
   */
  private String skuNotcontains;
  /**
   * sku 比较(startswith)
   */
  private String skuStartswith;
  /**
   * sku 比较(endswith)
   */
  private String skuEndswith;
  /**
   * sku 比较(isnull)
   */
  private Boolean skuIsnull;
  /**
   * sku 比较(isnotnull)
   */
  private Boolean skuIsnotnull;

  /**
   * sku(精确搜索)
   */
  private List<String> skuInList;

  /**
   * 国家(模糊搜索)
   */
  private String country;

  /**
   * 国家 比较(eq)
   */
  private String countryEq;
  /**
   * 国家 比较(neq)
   */
  private String countryNeq;
  /**
   * 国家 比较(gt)
   */
  private String countryGt;
  /**
   * 国家 比较(gte)
   */
  private String countryGte;
  /**
   * 国家 比较(lt)
   */
  private String countryLt;
  /**
   * 国家 比较(lte)
   */
  private String countryLte;
  /**
   * 国家 比较(contains)
   */
  private String countryContains;
  /**
   * 国家 比较(notcontains)
   */
  private String countryNotcontains;
  /**
   * 国家 比较(startswith)
   */
  private String countryStartswith;
  /**
   * 国家 比较(endswith)
   */
  private String countryEndswith;
  /**
   * 国家 比较(isnull)
   */
  private Boolean countryIsnull;
  /**
   * 国家 比较(isnotnull)
   */
  private Boolean countryIsnotnull;

  /**
   * 国家(精确搜索)
   */
  private List<String> countryInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
